{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Deep Deterministic Policy Gradient\n",
    "\n",
    "https://arxiv.org/pdf/1509.02971.pdf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import deque, namedtuple\n",
    "from matplotlib import pyplot as plt\n",
    "import numpy as np\n",
    "import random\n",
    "import gym\n",
    "import pdb\n",
    "\n",
    "from src.utils.OUNoise import OUNoise \n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import torch.nn.functional as F\n",
    "from torch.distributions import Categorical"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Define Networks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Actor(nn.Module):\n",
    "    def __init__(self, state_space, action_space):\n",
    "        super(Actor, self).__init__()\n",
    "        \n",
    "        self.noise = OUNoise(action_space)\n",
    "        \n",
    "        self.head = nn.Sequential(\n",
    "            nn.Linear(state_space, 512),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(512, 128),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(128, action_space),\n",
    "            nn.Tanh()\n",
    "        )\n",
    "    \n",
    "    def forward(self, x):\n",
    "        return self.head(x)\n",
    "    \n",
    "    def act(self, state, add_noise=True):\n",
    "        \n",
    "        state = torch.from_numpy(state).float().to(device)\n",
    "        \n",
    "        action = self.forward(state).cpu().data.numpy()\n",
    "        if add_noise:\n",
    "            action += self.noise.noise()\n",
    "\n",
    "        return np.clip(action, -1, 1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Critic(nn.Module):\n",
    "    def __init__(self, state_space, action_space):\n",
    "        super(Critic, self).__init__()\n",
    "        \n",
    "        self.head = nn.Sequential(\n",
    "            nn.Linear(state_space, 1024),\n",
    "            nn.ReLU(),\n",
    "        )\n",
    "        \n",
    "        self.body = nn.Sequential(\n",
    "            nn.Linear(1024 + action_space, 512),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(512, 300),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(300, 1),\n",
    "        )\n",
    "    \n",
    "    def forward(self, x, actions):\n",
    "        x = self.head(x)\n",
    "        x = self.body(torch.cat((x, actions), dim=1))\n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create environment with Agents"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "https://github.com/openai/gym/wiki/Pendulum-v0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "State space: 3\n",
      "Action space: 1\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ubuntu/anaconda3/lib/python3.6/site-packages/gym/logger.py:30: UserWarning: \u001b[33mWARN: Box bound precision lowered by casting to float32\u001b[0m\n",
      "  warnings.warn(colorize('%s: %s'%('WARN', msg % args), 'yellow'))\n"
     ]
    }
   ],
   "source": [
    "import gym\n",
    "\n",
    "env_name = \"Pendulum-v0\"\n",
    "env = gym.make(env_name)\n",
    "\n",
    "state_space = env.observation_space.shape[0]\n",
    "action_space = env.action_space.shape[0]\n",
    "\n",
    "print(\"State space: {}\".format(state_space))\n",
    "print(\"Action space: {}\".format(action_space))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "actor = Actor(state_space, action_space).to(device)\n",
    "critic = Critic(state_space, action_space).to(device)\n",
    "\n",
    "actor_target = Actor(state_space, action_space).to(device)\n",
    "critic_target = Critic(state_space, action_space).to(device)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Replay Buffer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ReplayBuffer:\n",
    "    def __init__(self, buffer_size):\n",
    "        self.buffer = deque(maxlen=int(buffer_size))\n",
    "        self.Experience = namedtuple(\"experience\", [\"state\", \"action\", \"reward\", \"next_state\", \"done\"])\n",
    "    \n",
    "    def push(self, state, action, reward, next_state, done):\n",
    "        e = self.Experience(state, action, np.array([reward]), next_state ,done)\n",
    "        self.buffer.append(e)\n",
    "    \n",
    "    def sample(self, batch_size):\n",
    "        samples = random.sample(self.buffer, batch_size)\n",
    "        \n",
    "        states = [ exp.state for exp in samples]\n",
    "        actions = [ exp.action for exp in samples]\n",
    "        rewards = [ exp.reward for exp in samples]\n",
    "        next_states = [ exp.next_state for exp in samples]\n",
    "        dones = [ exp.done for exp in samples]\n",
    "        \n",
    "        return (states, actions, rewards, next_states, dones)\n",
    "    \n",
    "    def __len__(self):\n",
    "        return len(self.buffer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Computing loss and updating Networks\n",
    "\n",
    "This code has broken up the update for the actor and critic seperately so it's easy to see what's going on."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "actor_optimiser = optim.Adam(actor.parameters(), lr=1e-3)\n",
    "critic_optimiser = optim.Adam(critic.parameters(), lr=1e-3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "def learn():\n",
    "\n",
    "    state_batch, action_batch, reward_batch, next_state_batch, masks = mem.sample(batch_size)\n",
    "    \n",
    "    state_batch = torch.FloatTensor(state_batch).to(device)\n",
    "    action_batch = torch.FloatTensor(action_batch).to(device)\n",
    "    reward_batch = torch.FloatTensor(reward_batch).to(device)\n",
    "    next_state_batch = torch.FloatTensor(next_state_batch).to(device)\n",
    "    masks = torch.FloatTensor(masks).to(device)\n",
    "\n",
    "    # Update Critic\n",
    "    update_critic(\n",
    "        states=state_batch,\n",
    "        next_states=next_state_batch,\n",
    "        actions=action_batch,\n",
    "        rewards=reward_batch,\n",
    "        dones=masks\n",
    "    )\n",
    "    \n",
    "    # Update actor\n",
    "    update_actor(states=state_batch)\n",
    "    \n",
    "    # Update target networks\n",
    "    update_target_networks()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Actor Update\n",
    "\n",
    "The **critic** is responsible for calculating the loss from the **actor**. Essentially, we look at the actions that the actor took in the given state, and then work out how good that action was.\n",
    "\n",
    "<img src=\"./img/ddpg/actor_update.png\" alt=\"Drawing\" style=\"height: 50px;\"/>\n",
    "\n",
    "This complicated looking formula is basically saying:\n",
    "\n",
    "> The loss is the average of the estimated Q value from the critic, given the action taken by the actor in a given state.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "def update_actor(states):\n",
    "    actions_pred = actor(states)  \n",
    "    loss = -critic(states, actions_pred).mean()\n",
    "    \n",
    "    actor_optimiser.zero_grad()\n",
    "    loss.backward()\n",
    "    actor_optimiser.step()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Critic Update\n",
    "\n",
    "The critic update looks very similar to that of a DQN. The loss of the critic is **mean squared error** of the **Q value** which we predicted with our current network, and what the actual reward was + the discounted future reward from our target critic network.\n",
    "\n",
    "#### Critic Loss:\n",
    "<img src=\"./img/ddpg/critic_loss.png\" alt=\"Drawing\" style=\"height: 30px;\"/>\n",
    "\n",
    "#### Critic $y_i$:\n",
    "<img src=\"./img/ddpg/critic_yi.png\" alt=\"Drawing\" style=\"height: 35px;\"/>\n",
    "\n",
    "Essentially it is working out:\n",
    "> How right was I in predicting the current state I am in."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "def update_critic(states, next_states, actions, rewards, dones):\n",
    "    next_actions = actor_target.forward(next_states)\n",
    "    \n",
    "    y_i =  rewards + ( gamma * critic_target(next_states, next_actions) * (1-dones ))\n",
    "    expected_Q = critic(states, actions)\n",
    "\n",
    "    loss = F.mse_loss(y_i, expected_Q)\n",
    "    \n",
    "    critic_optimiser.zero_grad()\n",
    "    loss.backward()\n",
    "    critic_optimiser.step()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Soft Weights Updates\n",
    "\n",
    "Because the DDPG network is prone to divergance, as with our DQN, we \"phase in\" the weights from our current network to our target network slowly. This is to give the networks consistant targets during back propogation.\n",
    "\n",
    "<img src=\"./img/ddpg/target_update.png\" alt=\"Drawing\" style=\"height:100px;\"/>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "def update_target_networks():\n",
    "    for target, local in zip(actor_target.parameters(), actor.parameters()):\n",
    "        target.data.copy_(tau*local.data + (1.0-tau)*target.data)\n",
    "        \n",
    "    for target, local in zip(critic_target.parameters(), critic.parameters()):\n",
    "        target.data.copy_(tau*local.data + (1.0-tau)*target.data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Runner"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "max_e = 300\n",
    "max_t = 700\n",
    "buffer_size = 100000\n",
    "batch_size = 32\n",
    "learn_every = 1\n",
    "\n",
    "gamma = 0.99\n",
    "tau = 1e-2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "mem = ReplayBuffer(buffer_size)\n",
    "\n",
    "score_log = []\n",
    "average_score_log = []\n",
    "score_window = deque(maxlen=100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ubuntu/anaconda3/lib/python3.6/site-packages/ipykernel_launcher.py:7: UserWarning: Using a target size (torch.Size([32, 1])) that is different to the input size (torch.Size([32, 32])). This will likely lead to incorrect results due to broadcasting. Please ensure they have the same size.\n",
      "  import sys\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epsiode: 0.0\tWindow Score: -1578.4058\tScore: -1578.4058\n",
      "Epsiode: 25.0\tWindow Score: -655.1124\tScore: -123.31264\n",
      "Epsiode: 50.0\tWindow Score: -475.2676\tScore: -355.38727\n",
      "Epsiode: 75.0\tWindow Score: -412.6385\tScore: -479.9304\n",
      "Epsiode: 100.0\tWindow Score: -356.4419\tScore: -123.9078\n",
      "Epsiode: 125.0\tWindow Score: -277.1858\tScore: -479.6070\n",
      "Epsiode: 150.0\tWindow Score: -270.2243\tScore: -494.0729\n",
      "Epsiode: 175.0\tWindow Score: -272.8297\tScore: -480.2960\n",
      "Epsiode: 200.0\tWindow Score: -292.8698\tScore: -499.2568\n",
      "Epsiode: 225.0\tWindow Score: -277.8800\tScore: -244.7748\n",
      "Epsiode: 250.0\tWindow Score: -283.7781\tScore: -363.6177\n",
      "Epsiode: 275.0\tWindow Score: -271.5517\tScore: -123.4970\n",
      "Epsiode: 299.0\tWindow Score: -270.1430\tScore: -127.8622"
     ]
    }
   ],
   "source": [
    "for episode in range(max_e):\n",
    "    state = env.reset()\n",
    "    score = 0\n",
    "    for t in range(max_t):\n",
    "        action = actor.act(state, add_noise=False)\n",
    "        next_state, reward, done, _ = env.step(action)\n",
    "        mem.push(state, action, reward, next_state, done)\n",
    "        score += reward\n",
    "\n",
    "\n",
    "        \n",
    "        if len(mem) > batch_size and t % learn_every == 0:\n",
    "            learn()\n",
    "\n",
    "        if done:\n",
    "            break;\n",
    "        \n",
    "        state = next_state\n",
    "    \n",
    "    score_log.append(score)\n",
    "    score_window.append(score)\n",
    "    average_score_log.append(np.mean(score_window))\n",
    "    \n",
    "    print(\"\\rEpsiode: {:.1f}\\tWindow Score: {:.4f}\\tScore: {:.4f}\".format(episode, np.mean(score_window), score), end=\"\")    \n",
    "    if (episode % 25 == 0):\n",
    "        print(\"\\rEpsiode: {:.1f}\\tWindow Score: {:.4f}\\tScore: {:.4f}\".format(episode, np.mean(score_window), score))\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f5fd16a2c50>]"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(score_log)\n",
    "plt.plot(average_score_log)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.save(actor.state_dict(), \"{}_actor_model.pth\".format(env_name))\n",
    "torch.save(critic.state_dict(), \"{}_critic_model.pth\".format(env_name))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Watch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for episode in range(3):\n",
    "    state = env.reset()\n",
    "    score = 0\n",
    "    input()\n",
    "\n",
    "    for t in range(max_t):\n",
    "        action = actor.act(state, add_noise=False)\n",
    "        next_state, reward, done, _ = env.step(action)\n",
    "        env.render()\n",
    "        \n",
    "        score += reward\n",
    "        \n",
    "        if done:\n",
    "            print(score)\n",
    "            break;\n",
    "\n",
    "env.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
